home *** CD-ROM | disk | FTP | other *** search
/ Aminet 22 / Aminet 22 (1997)(GTI - Schatztruhe)[!][Dec 1997].iso / Aminet / dev / src / ConfigFileSrc.lha / ConfigFileSrc12 / RexxLibrary / CFConv.c < prev    next >
Encoding:
Text File  |  1997-10-02  |  6.6 KB  |  244 lines
  1. /*
  2. **        $PROJECT: RexxConfigFile.library
  3. **        $FILE: CFConv.c
  4. **        $DESCRIPTION: Functions for conversion between cf and rxcf.
  5. **
  6. **        (C) Copyright 1997 Marcel Karas
  7. **             All Rights Reserved.
  8. */
  9.  
  10. IMPORT struct Library *DOSBase;
  11.  
  12. VOID ErrOpenToStr ( RXCFStrConv * ErrCode , UBYTE CFErr )
  13. {
  14.     switch (CFErr)
  15.     {
  16.         case CF_OERR_OPEN_FILE:        ErrCode->Str    = "OERR_OPEN_FILE";
  17.                                             ErrCode->Len    = 14; break;
  18.         case CF_OERR_READ_FILE:        ErrCode->Str    = "OERR_READ_FILE";
  19.                                             ErrCode->Len    = 14; break;
  20.         case CF_OERR_NO_FORMAT:        ErrCode->Str    = "OERR_NO_FORMAT";
  21.                                             ErrCode->Len    = 14; break;
  22.         case CF_OERR_NO_SIZE:        ErrCode->Str    = "OERR_NO_SIZE";
  23.                                             ErrCode->Len    = 12; break;
  24.         case CF_OERR_HEADER_MEM:    ErrCode->Str    = "OERR_HEADER_MEM";
  25.                                             ErrCode->Len    = 15; break;
  26.  
  27.         case CF_RERR_FORMAT:            ErrCode->Str    = "RERR_FORMAT";
  28.                                             ErrCode->Len    = 11; break;
  29.         case CF_RERR_UNKOWN_ITYPE:    ErrCode->Str    = "RERR_UNKOWN_ITYPE";
  30.                                             ErrCode->Len    = 17; break;
  31.  
  32.         default:                            ErrCode->Str    = "OERR_UNKOWN";
  33.                                             ErrCode->Len    = 11; break;
  34.     }
  35. }
  36.  
  37. VOID ErrReadToStr ( RXCFStrConv * ErrCode , UBYTE CFErr )
  38. {
  39.     switch (CFErr)
  40.     {
  41.         case CF_RERR_BUFFER_MEM:    ErrCode->Str    = "RERR_BUFFER_MEM";
  42.                                             ErrCode->Len    = 15; break;
  43.         case CF_RERR_READ_FILE:        ErrCode->Str    = "RERR_READ_FILE";
  44.                                             ErrCode->Len    = 14; break;
  45.         case CF_RERR_FORMAT:            ErrCode->Str    = "RERR_FORMAT";
  46.                                             ErrCode->Len    = 11; break;
  47.         case CF_RERR_UNKOWN_ITYPE:    ErrCode->Str    = "RERR_UNKOWN_ITYPE";
  48.                                             ErrCode->Len    = 17; break;
  49.  
  50.         default:                            ErrCode->Str    = "RERR_UNKOWN";
  51.                                             ErrCode->Len    = 11; break;
  52.     }
  53. }
  54.  
  55. VOID ErrWriteToStr ( RXCFStrConv * ErrCode , UBYTE CFErr )
  56. {
  57.     switch (CFErr)
  58.     {
  59.         case CF_WERR_ALLOC_WBUFFER:ErrCode->Str    = "WERR_ALLOC_WBUFFER";
  60.                                             ErrCode->Len    = 18; break;
  61.  
  62.         default:                            ErrCode->Str    = "WERR_UNKOWN";
  63.                                             ErrCode->Len    = 11; break;
  64.     }
  65. }
  66.  
  67. VOID TypeToStr ( RXCFStrConv * TypeConv , UBYTE Type )
  68. {
  69.     switch (Type)
  70.     {
  71.         case CF_ITYP_STRING:    TypeConv->Str    = "ITYP_STRING";
  72.                                     TypeConv->Len    = 11; break;
  73.         case CF_ITYP_NUMBER:    TypeConv->Str    = "ITYP_NUMBER";
  74.                                     TypeConv->Len    = 11; break;
  75.         case CF_ITYP_BOOL:    TypeConv->Str    = "ITYP_BOOL";
  76.                                     TypeConv->Len    =  9; break;
  77.  
  78.         default:                    TypeConv->Str    = "ITYP_UNKOWN";
  79.                                     TypeConv->Len    = 11; break;
  80.     }
  81. }
  82.  
  83. VOID STypeNumToStr ( RXCFStrConv * STypeConv , UBYTE SType )
  84. {
  85.     switch (SType)
  86.     {
  87.         case CF_STYP_NUM_DEFAULT:    STypeConv->Str    = "STYP_NUM_DEFAULT";
  88.                                             STypeConv->Len    = 16; break;
  89.         case CF_STYP_NUM_DEC:        STypeConv->Str    = "STYP_NUM_DEC";
  90.                                             STypeConv->Len    = 12; break;
  91.         case CF_STYP_NUM_HEX:        STypeConv->Str    = "STYP_NUM_HEX";
  92.                                             STypeConv->Len    = 12; break;
  93.         case CF_STYP_NUM_BIN:        STypeConv->Str    = "STYP_NUM_BIN";
  94.                                             STypeConv->Len    = 12; break;
  95.  
  96.         default:                            STypeConv->Str    = "STYP_UNKOWN";
  97.                                             STypeConv->Len    = 11; break;
  98.     }
  99. }
  100.  
  101. VOID STypeBoolToStr ( RXCFStrConv * STypeConv , UBYTE SType )
  102. {
  103.     switch (SType)
  104.     {
  105.         case CF_STYP_BOOL_DEFAULT:    STypeConv->Str    = "STYP_BOOL_DEFAULT";
  106.                                             STypeConv->Len    = 17; break;
  107.         case CF_STYP_BOOL_TRUE:        STypeConv->Str    = "STYP_BOOL_TRUE";
  108.                                             STypeConv->Len    = 14; break;
  109.         case CF_STYP_BOOL_YES:        STypeConv->Str    = "STYP_BOOL_YES";
  110.                                             STypeConv->Len    = 14; break;
  111.         case CF_STYP_BOOL_ON:        STypeConv->Str    = "STYP_BOOL_ON";
  112.                                             STypeConv->Len    = 14; break;
  113.  
  114.         default:                            STypeConv->Str    = "STYP_UNKOWN";
  115.                                             STypeConv->Len    = 11; break;
  116.     }
  117. }
  118.  
  119. VOID OModeToStr ( RXCFStrConv * OModeConv , UBYTE OMode )
  120. {
  121.     switch (OMode)
  122.     {
  123.         case CF_OMODE_OLDFILE:        OModeConv->Str    = "OMODE_OLDFILE";
  124.                                             OModeConv->Len    = 13; break;
  125.         case CF_OMODE_NEWFILE:        OModeConv->Str    = "OMODE_NEWFILE";
  126.                                             OModeConv->Len    = 13; break;
  127.         case CF_OMODE_READWRITE:    OModeConv->Str    = "OMODE_READWRITE";
  128.                                             OModeConv->Len    = 15; break;
  129.  
  130.         default:                            OModeConv->Str    = "OMODE_UNKOWN";
  131.                                             OModeConv->Len    = 12; break;
  132.     }
  133. }
  134.  
  135. BYTE StrToOMode ( STRPTR OModeStr )
  136. {
  137.     if ( !StrCmp (OModeStr, "OMODE_OLDFILE") )
  138.         return (CF_OMODE_OLDFILE);
  139.     else if ( !StrCmp (OModeStr, "OMODE_NEWFILE") )
  140.         return (CF_OMODE_NEWFILE);
  141.     else if ( !StrCmp (OModeStr, "OMODE_READWRITE") )
  142.         return (CF_OMODE_READWRITE);
  143.  
  144.     return (-1);
  145. }
  146.  
  147. WORD StrToHdrFlag ( STRPTR FlagStr )
  148. {
  149.     if ( !StrCmp (FlagStr, "HFLG_SHORT_FILE") )
  150.         return (CF_HFLG_SHORT_FILE);
  151.     else if ( !StrCmp (FlagStr, "HFLG_ASCII_FILE") )
  152.         return (CF_HFLG_ASCII_FILE);
  153.     else if ( !StrCmp (FlagStr, "HFLG_CHANGED") )
  154.         return (CF_HFLG_CHANGED);
  155.     else if ( !StrCmp (FlagStr, "HFLG_WRITE_BY_CLOSE") )
  156.         return (CF_HFLG_WRITE_BY_CLOSE);
  157.  
  158.     return (-1);
  159. }
  160.  
  161. WORD StrToType ( STRPTR TypeStr )
  162. {
  163.     if ( !StrCmp (TypeStr, "ITYP_STRING") )
  164.         return (CF_ITYP_STRING);
  165.     else if ( !StrCmp (TypeStr, "ITYP_NUMBER") )
  166.         return (CF_ITYP_NUMBER);
  167.     else if ( !StrCmp (TypeStr, "ITYP_BOOL") )
  168.         return (CF_ITYP_BOOL);
  169.  
  170.     return (-1);
  171. }
  172.  
  173. WORD StrToSTypeNum ( STRPTR STypeStr )
  174. {
  175.     if ( !StrCmp (STypeStr, "STYP_NUM_DEFAULT") )
  176.         return (CF_STYP_NUM_DEFAULT);
  177.     else if ( !StrCmp (STypeStr, "STYP_NUM_DEC") )
  178.         return (CF_STYP_NUM_DEC);
  179.     else if ( !StrCmp (STypeStr, "STYP_NUM_HEX") )
  180.         return (CF_STYP_NUM_HEX);
  181.     else if ( !StrCmp (STypeStr, "STYP_NUM_BIN") )
  182.         return (CF_STYP_NUM_BIN);
  183.  
  184.     return (-1);
  185. }
  186.  
  187. WORD StrToSTypeBool ( STRPTR STypeStr )
  188. {
  189.     if ( !StrCmp (STypeStr, "STYP_BOOL_DEFAULT") )
  190.         return (CF_STYP_BOOL_DEFAULT);
  191.     else if ( !StrCmp (STypeStr, "STYP_BOOL_TRUE") )
  192.         return (CF_STYP_BOOL_TRUE);
  193.     else if ( !StrCmp (STypeStr, "STYP_BOOL_YES") )
  194.         return (CF_STYP_BOOL_YES);
  195.     else if ( !StrCmp (STypeStr, "STYP_BOOL_ON") )
  196.         return (CF_STYP_BOOL_ON);
  197.  
  198.     return (-1);
  199. }
  200.  
  201. BOOL ConvItemStrings ( struct RexxMsg * RxMsg, RXCFItemConv * ItemConv,
  202.                     ULONG ContentsNum, UBYTE TypeNum, UBYTE STypeNum )
  203. {
  204.     UBYTE    Result = FALSE;
  205.  
  206.     if ( TypeNum && IsValidArg (RxMsg, TypeNum) )
  207.     {
  208.         ItemConv->Type = StrToType (RXARG(TypeNum));
  209.         if ( ItemConv->Type == -1 ) return (FALSE);
  210.         Result = TRUE;
  211.     }
  212.     else    ItemConv->Type = CF_ITYP_STRING;
  213.  
  214.     if ( STypeNum && IsValidArg (RxMsg, STypeNum) )
  215.     {
  216.         if ( ItemConv->Type == CF_ITYP_NUMBER )
  217.             ItemConv->SType = StrToSTypeNum  (RXARG(STypeNum));
  218.         else if ( ItemConv->Type == CF_ITYP_BOOL )
  219.             ItemConv->SType = StrToSTypeBool (RXARG(STypeNum));
  220.         else    ItemConv->SType = CF_STYP_NUM_DEFAULT;
  221.  
  222.         if ( ItemConv->SType == -1 ) return (FALSE);
  223.         Result = TRUE;
  224.     }
  225.     else    ItemConv->SType = CF_STYP_NUM_DEFAULT;
  226.  
  227.     if ( ContentsNum && IsValidArg (RxMsg, ContentsNum) )
  228.     {
  229.         if ( ItemConv->Type == CF_ITYP_STRING )
  230.             ItemConv->Contents = (ULONG)RXARG(ContentsNum);
  231.         else
  232.         {
  233.             if ( StrToLong (RXARG(ContentsNum),
  234.                     (LONG *)&ItemConv->Contents) == -1 )
  235.                 return (FALSE);
  236.         }
  237.         Result = TRUE;
  238.     }
  239.     else    ItemConv->Contents = 0;
  240.  
  241.     return (Result);
  242. }
  243.  
  244.